
import java.io.Serializable;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.TreeMap;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
 * Classe controleur et application (système)
 * @author IUT,   A. Culet
 * @version 1.0 
 */

//public class Controleur extends Observable implements Serializable{
public class Controleur implements Serializable{
	

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	/**
	 * 
	 */
	/**
	 * La classe Controleur est unique pour tous les cas d'utilisation
	 * Elle est également la classe "application" qui gère l'ensemble des objets de l'appli
	 */	
	// ************************************************************************************************************
		// Attributs
		// ************************************************************************************************************
	
		// Attributs d'Association
		// Ensemble des ouvrages de la bibliothèque
		private HashMap<String, Ouvrage> _ouvrages; 
		private HashMap<String, Periodique> _periodiques; 
		private TreeMap<String, Auteur> _auteurs;
		private TreeMap<String, MotsCles> _motsCles;
		private HashMap<String, Parution> _parutions;     // Ensemble des parutions
		private TreeMap<String, Article> _articles; 
		// les différentes fenêtres pour chaque fonctionnalité
		private VueMenuBiblio _vueMenuBiblio = null;
		
		// une seule fenêtre est active à la fois; les autres sont à null.
		// permet de connaître l'état des fenêtres de l'interface
		private VueSaisieOuvrage _vueSaisieOuvrage = null;
		private VueSaisieExemplaire _vueSaisieExemplaire = null;
		private VueConsultOuvrage _vueConsultOuvrage = null;
		private VueSaisiePeriodique _vueSaisiePeriodique = null;
		private VueSaisieParution _vueSaisieParution = null;
		private VueSaisieArticle _vueSaisieArticle=null;
		private VueConsultPeriodique _vueConsultPeriodique=null;
		private VueRechercheParMotsCles _vueRechercheParMotsCles=null;
		private VueRechercheParAuteur _vueRechercheParAuteur=null;
		// ************************************************************************************************************
		// Constructeur
		// ************************************************************************************************************

		public Controleur() {
			
			this.setOuvrages(new HashMap<String, Ouvrage>());
			this.setPeriodiques(new HashMap<String,Periodique>());
			this.setAuteurs(new TreeMap<String, Auteur>());
			this.setMotsCles(new TreeMap<String, MotsCles>());
			this.setParutions(new HashMap<String,Parution>());
			this.setArticles(new TreeMap<String,Article>());
		} // Fin Controleur



		// ************************************************************************************************************
		// Méthodes privées
		// ************************************************************************************************************

		// ------------------------------------------------------------------------------------------------------------
		// Affecteurs
		
		/**
		 * Ajoute un ouvrage à l'ensemble des ouvrages de la bibliothèque.
		 * @param ouvrage 	Ouvrage à ajouter
		 * @param isbn 	code ISBN de cet ouvrage
		 */
		private void setOuvrage(Ouvrage ouvrage, String isbn) {
			this.getOuvrages().put(isbn, ouvrage);
		} // Fin setOuvrage
		
		/**
		 * Ajoute un periodique à l'ensemble des periodiques de la bibliothèque.
		 * @param periodique 	Periodique à ajouter
		 * @param issn 	code ISSN de ce periodique
		 */

		private void setPeriodique(Periodique periodique,String issn){
			this.getPeriodiques().put(issn, periodique);
		}

		private void setParution(Parution parution,String identifiant){
			this.getParutions().put(identifiant,parution);
		}
		
		private void setArticle(Article article,String titre){
			this.getArticles().put(titre,article);
		}
		
		
		/**
		 * @param ouvrages hashtable d'ouvrages à affecter
		 */
		private void setOuvrages(HashMap<String, Ouvrage> ouvrages) {
			_ouvrages = ouvrages;
		}// Fin setOuvrages
		
		private void setPeriodiques(HashMap<String, Periodique> periodiques) {
			_periodiques = periodiques;
		}// Fin setOuvrages
		
		private void setParutions(HashMap<String, Parution> parutions) {
			_parutions = parutions;
		}// Fin setOuvrages
		
		private void setAuteurs(TreeMap<String, Auteur> auteurs) {
			_auteurs = auteurs;
		}// Fin setAuteur
		
		private void setArticles(TreeMap<String, Article> articles) {
			_articles = articles;
		}// Fin setAuteur
		
		private void setMotsCles(TreeMap<String, MotsCles> mots) {
			this._motsCles = mots; 					// cr�ation de l'ensemble de mots cles

			boolean marche = this.lectureLignesFichier("/users/info/etu-s3/delauzum/workspace/biblio/src/ListeAutorite.txt"); // on verifie si la creation a fonctionnee

		

			if (!marche) {												// si erreur � la creation de l'ensemble, on le signale
				Message dialog = new Message("Probleme de lecture fichier");
				dialog.setVisible(true);
			}
		}
		/**
		 * @param vue  la vue à affecter
		 */
		private void setVueMenuBiblio(VueMenuBiblio vue) {
			_vueMenuBiblio = vue;
		}// Fin getVueVueMenuBiblio
		
		private void setVueSaisieOuvrage(VueSaisieOuvrage vue) {
			_vueSaisieOuvrage = vue;
		}// Fin setVueVueSaisieOuvrage
		
		private void setVueSaisieExemplaire(VueSaisieExemplaire vue) {
			_vueSaisieExemplaire = vue;
		}// Fin setVueVueSaisieExemplaire
		
		private void setVueConsultOuvrage(VueConsultOuvrage vue) {
			_vueConsultOuvrage = vue;
		}// Fin setVueVueConsultOuvrage
		
		private void setVueSaisiePeriodique (VueSaisiePeriodique vue) {
			_vueSaisiePeriodique = vue;
		}
		
		private void setVueSaisieParution (VueSaisieParution vue) {
			_vueSaisieParution = vue;
		}
		
		private void setVueSaisieArticle (VueSaisieArticle vue) {
			_vueSaisieArticle = vue;
		}
		
		private void setVueConsultPeriodique(VueConsultPeriodique vue){
			_vueConsultPeriodique = vue;
		}
		
		private void setVueRechercheParMotsCles (VueRechercheParMotsCles vue){
			_vueRechercheParMotsCles = vue;
		}
		
		private void setVueRechercheParAuteur (VueRechercheParAuteur vue){
			_vueRechercheParAuteur = vue;
		}
		// ------------------------------------------------------------------------------------------------------------
		// Accesseurs
		
		/**
		 * @return ensemble des ouvrages de la bibliothèque
		 */
		public HashMap<String, Ouvrage> getOuvrages() {
			return _ouvrages;
		}// Fin getOuvrages

		public TreeMap<String, Auteur> getAuteurs() {
			return _auteurs;
		}
		
		public  TreeMap<String, MotsCles> getMotsCles() {
			return _motsCles;
		}
		
		private HashMap<String, Periodique> getPeriodiques(){
			return _periodiques;
		}
		
		private HashMap<String, Parution> getParutions(){
			return _parutions;
		}
		
		public TreeMap<String, Article> getArticles(){
			return _articles;
		}
		/**
		 * Accès à un ouvrage par son numéro ISBN
		 * @param isbn 	le code ISBN de l'ouvrage cherché
		 * @return l'ouvrage qui a l'ISBN indiqué
		 */
		private Ouvrage getOuvrage(String isbn) {
			return this.getOuvrages().get(isbn);
		} // Fin getOuvrage
		
		public Periodique getPeriodique(String issn){
			return this.getPeriodiques().get(issn);
		}
		
		public Parution getParution(String identifiant){
			return this.getParutions().get(identifiant);
		}
		
		Article getArticle(String titre) {
			return this.getArticles().get(titre);
		} // Fin getOuvrage
		
		public Auteur getAuteur(String nom) {
			return this.getAuteurs().get(nom);
		} // Fin getOuvrage
		
		private void lierAuteur(String nom, String prenom, Auteur auteur) {
			String cle= nom;
			this.getAuteurs().put(cle, auteur);
			//getVueSaisieOuvrage().alimenteListeAuteur(this.getAuteurs());
			Message dialog = new Message("Auteur enregistr�");
			dialog.setVisible(true);
		} // Fin lierAuteur

		private void lierMotsCles(MotsCles motsCles,String mot) {
			this.getMotsCles().put(mot,motsCles);
		} // Fin lierMotsCles
		/**
		 * @return la vue  
		 */
		private VueMenuBiblio getVueMenuBiblio() {
			return _vueMenuBiblio ;
		}// Fin getVueVueMenuBiblio
		
		private VueSaisieOuvrage getVueSaisieOuvrage() {
			return _vueSaisieOuvrage ;
		}// Fin getVueVueSaisieOuvrage
		
		private VueSaisieExemplaire getVueSaisieExemplaire() {
			return _vueSaisieExemplaire ;
		}// Fin getVueVueSaisieExemplaire
		
		private VueConsultOuvrage getVueConsultOuvrage() {
			return _vueConsultOuvrage ;
		}// Fin getVueVueConsultOuvrage
		
		private VueSaisiePeriodique getVueSaisiePeriodique(){
			return _vueSaisiePeriodique;
			
		}
		private VueSaisieParution getVueSaisieParution(){
			return _vueSaisieParution;
			
		}
		
		private VueSaisieArticle getVueSaisieArticle(){
			return _vueSaisieArticle;
			
		}
		private VueConsultPeriodique getVueConsultPeriodique(){
			return _vueConsultPeriodique;
		}
		
		private VueRechercheParMotsCles getVueRechercheParMotsCles(){
			return _vueRechercheParMotsCles;
		}
		
		private VueRechercheParAuteur getVueRechercheParAuteur(){
			return _vueRechercheParAuteur;
		}
		
		// ************************************************************************************************************
		// Méthodes publiques de création et affichage des fenêtres de l'application et fermeture
		// ************************************************************************************************************
		/**
		 * Création et affichage de la fenêtre principale de l'application. 
		 * Elle reste affichée
		 */
		
		public void menuBiblio() {
			try {this.setVueMenuBiblio(new VueMenuBiblio(this));	
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Création et affichage de la fenêtre de consultation d'un ouvrage
		 */
		
		public void consulterOuvrage() {
			try {this.setVueConsultOuvrage (new VueConsultOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 	
			// la vue courante est VueConsultOuvrage
				this.getVueConsultOuvrage().setEtat(Vue.initiale);
				this.getVueConsultOuvrage().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Création et affichage de la fenêtre de saisie d'un exemplaire d'ouvrage
		 */
		public void saisirExemplaire() {
			try {this.setVueSaisieExemplaire(new VueSaisieExemplaire(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieExemplaire
				this.getVueSaisieExemplaire().setEtat(Vue.initiale);
				this.getVueSaisieExemplaire().setVisible(true);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		/**
		 * Création et affichage de la fenêtre de saisie d'un ouvrage
		 */
		public void saisirOuvrage() {
			try {this.setVueSaisieOuvrage(new VueSaisieOuvrage(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
				this.getVueSaisieOuvrage().setEtat(Vue.initiale);
				this.getVueSaisieOuvrage().setVisible(true);
				this.getVueSaisieOuvrage().alimenteListeAuteur(this.getAuteurs());
				this.getVueSaisieOuvrage().alimenteListeMot(this.getMotsCles());
			} catch (Exception e) {
			e.printStackTrace();
			}
		}
		
		/**
		 * Création et affichage de la fenêtre de saisie d'un nouveau periodique
		 */
		public void nouveauPeriodique(){
			try {this.setVueSaisiePeriodique(new VueSaisiePeriodique(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
			this.getVueSaisiePeriodique().setEtat(Vue.initiale);
			this.getVueSaisiePeriodique().setVisible(true);
			} catch (Exception e) {
			e.printStackTrace();
			}
			
		}
		
		/**
		 * Création et affichage de la fenêtre de saisie d'une nouvelle parution
		 */
		public void nouvelleParution(){
			try {this.setVueSaisieParution(new VueSaisieParution(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
			this.getVueSaisieParution().setEtat(Vue.initiale);
			this.getVueSaisieParution().setVisible(true);
			
			} catch (Exception e) {
			e.printStackTrace();
			}
			
		}
		
		/**
		 * Création et affichage de la fenêtre de cosultation d'un periodique
		 */
		public void consultPeriodique(){
			try {this.setVueConsultPeriodique(new VueConsultPeriodique(this));
			// le Menu est caché
			this.getVueMenuBiblio().getFrame().setVisible(false); 
			// la vue courante est VueSaisieOuvrage
			this.getVueConsultPeriodique().setEtat(Vue.initiale);
			this.getVueConsultPeriodique().setVisible(true);
			
			} catch (Exception e) {
			e.printStackTrace();
			}
			
		}
		
		/**
		 * Création et affichage de la fenêtre de saisie d'une nouvelle parution
		 */
		public void nouvelleArticle(){
			try {this.setVueSaisieArticle(new VueSaisieArticle(this));
			// le Menu est caché 
			// la vue courante est VueSaisieOuvrage
			this.getVueSaisieArticle().setEtat(Vue.initiale);
			this.getVueSaisieArticle().setVisible(true);
			this.getVueSaisieArticle().alimenteListeAuteur(this.getAuteurs());
			this.getVueSaisieArticle().alimenteListeMot(this.getMotsCles());
			} catch (Exception e) {
			e.printStackTrace();
			}
			
		}
		
		public void rechMotsCles(){
			try {this.setVueRechercheParMotsCles(new VueRechercheParMotsCles(this));
			// le Menu est caché 
			// la vue courante est VueSaisieOuvrage
			this.getVueRechercheParMotsCles().setEtat(Vue.initiale);
			this.getVueRechercheParMotsCles().setVisible(true);
			this.getVueRechercheParMotsCles().alimenteListeMot(this.getMotsCles());
			} catch (Exception e) {
			e.printStackTrace();
			}
			
		}
		
		public void rechAuteurs(){
			try {this.setVueRechercheParAuteur(new VueRechercheParAuteur(this));
			// le Menu est caché 
			// la vue courante est VueSaisieOuvrage
			this.getVueRechercheParAuteur().setEtat(Vue.initiale);
			this.getVueRechercheParAuteur().setVisible(true);
			this.getVueRechercheParAuteur().alimenteListeAuteur(this.getAuteurs());
			} catch (Exception e) {
			e.printStackTrace();
			}
			
		}
		
		
		/**
		 * fermeture de la fenêtre vue
		 * lors de la fermeture de la fenêtre principale de l'application sauvegarde des objets sérialisés 
		 */
		public void fermerVue (Vue vue) {
			if (vue instanceof VueMenuBiblio ) {	
			// Quitte l'aplication. Sauvegarde les objets du modèle
				this.sauve();
				System.exit(0);
				}
			vue.dispose();
			// le Menu est rendu de nouveau visible
			this.getVueMenuBiblio().getFrame().setVisible(true);
			this.resetVues();
		}
		
		// Restaure l'état de l'interface avec seule la fenêtre du Menu principal active
		private void resetVues() {
			this.setVueSaisieOuvrage (null);
			this.setVueConsultOuvrage(null);
			this.setVueSaisieExemplaire(null);
			this.setVueSaisiePeriodique(null);
		}
		
		// ************************************************************************************************************
		// Opérations liées à la sérialisation des objets de l'application
		// ************************************************************************************************************
		/**
		 *  restauration des objets de l'application
		 */
		public Controleur restaure() {
			try {
				FileInputStream fichier = new FileInputStream("Fsauv.ser");
				ObjectInputStream in = new ObjectInputStream(fichier);
				return((Controleur) in.readObject());
			} catch (Exception e) {
				Message dialog = new Message("Pbs de Restauration ou fichier non encore cr��");
				dialog.setVisible(true);
				return this;
			} 
		}
		/**
		 *  sauvegarde des objets de l'application
		 */
		private void sauve() {
			try {
				FileOutputStream f = new FileOutputStream("Fsauv.ser");
				ObjectOutputStream out = new ObjectOutputStream(f);
				out.writeObject(this);
			} catch (Exception e) {
				Message dialog = new Message("Pb de Sauvegarde dans le fichier");
				dialog.setVisible(true);
			}
		}
		// ************************************************************************************************************
		// Opérations liées à l'application en réponse à une action de l'utilisateur dans une vue
		// ************************************************************************************************************

		/**
		 * Accès à un ouvrage par son numéro ISBN
		 * Invoqué dans VueConsultOuvrage et VueSaisieExemplaire
		 * @param isbn 	le code ISBN de l'ouvrage cherché
		 * @return l'ouvrage qui a l'ISBN indiqué ou null
		 * affiche un message d'erreur si l'ouvrage n'est pas trouvé
		 */
		public Ouvrage rechOuvrage(String isbn) {
			Ouvrage ouv = this.getOuvrage(isbn);
			if (ouv == null) {
				Message dialog = new Message("Ouvrage inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueSaisieExemplaire
				if (this.getVueSaisieExemplaire() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage	
					ouv.addObserver(this.getVueSaisieExemplaire());
				// le contrôleur modifie l'état de la vue
					this.getVueSaisieExemplaire().setEtat(Vue.inter1);
					this.getVueSaisieExemplaire().alimente(ouv);
					}
				// la vue courante est VueConsultOuvrage
				if (this.getVueConsultOuvrage() != null) {
					// le contrôleur modifie l'état de la vue
					this.getVueConsultOuvrage().setEtat(Vue.finale);
					this.getVueConsultOuvrage().alimente(ouv);
					}
			}
			return ouv;
		} // Fin rechOuvrage
		
		public Periodique rechPeriodique1(String issn){
			Periodique per = this.getPeriodique(issn);
			if (per == null) {
				Message dialog = new Message("Periodique inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueSaisieExemplaire
				if (this.getVueConsultPeriodique() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage	
					per.addObserver(this.getVueConsultPeriodique());
				// le contrôleur modifie l'état de la vue
					this.getVueConsultPeriodique().setEtat(Vue.inter1);
					this.getVueConsultPeriodique().alimente(per);
					}
				
			}
			return per;
		} // Fin rechPeriodique
		
		public Parution rechParution(String ref){
			Parution par = this.getParution(ref);
			if (par == null) {
				Message dialog = new Message("Parution inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueSaisieExemplaire
				if (this.getVueConsultPeriodique() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage	
					par.addObserver(this.getVueConsultPeriodique());
				// le contrôleur modifie l'état de la vue
					this.getVueConsultPeriodique().setEtat(Vue.inter2);
					this.getVueConsultPeriodique().alimenteParution(par);
					}
				
			}
			return par;
		} // Fin rechParution
		
		public Article rechArticle(String titre){
			Article art = this.getArticle(titre);
			if (art == null) {
				Message dialog = new Message("Article inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueSaisieExemplaire
				if (this.getVueConsultPeriodique() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage	
					art.addObserver(this.getVueConsultPeriodique());
				// le contrôleur modifie l'état de la vue
					this.getVueConsultPeriodique().setEtat(Vue.inter3);
					this.getVueConsultPeriodique().alimenteArticle(art);
					}
				
			}
			return art;
		} // Fin rechParution
		
		/**
		 * Création d'un exemplaire d'ouvrage 
		 * Invoqué dans VueSaisieExemplaire
		 * @param ouv l'ouvrage  dateRecep la date de réception de l'exemplaire	
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvExemplaire(Ouvrage ouv, String dateReception, String statut) {
			// vérification de la présence de la date et de son format
			if (dateReception.length() == 0 ){
					Message dialog = new Message("La date de réception est obligatoire");
					dialog.setVisible(true);
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateReception);
				if (date == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					dialog.setVisible(true);
					}
				else {
					int statutEx;
					if (statut == "empruntable") {
						statutEx = Exemplaire.EMPRUNTABLE ; }
					else {
						statutEx = Exemplaire.EN_CONSULTATION ; }
			// demande d'ajout de l'exemplaire
					Exemplaire exemplaire = ouv.ajouterExemplaire(date, statutEx);
			// l'opération s'est bien passée
					if (exemplaire != null) {
			// le contrôleur modifie l'état de la vue
						this.getVueSaisieExemplaire().setEtat(Vue.finale);
			// affichage d'un message de confirmation
						Message dialog = new Message("Exemplaire enregistré");
						dialog.setVisible(true);
					}
					else {
						Message dialog = new Message("Date de Reception incorrecte / à la date d'Edition.");
						dialog.setVisible(true);
					}
				}
			}
		} // Fin nouvExemplaire
		
		/**
		 * Création d'un  d'ouvrage 
		 * Invoqué dans VueSaisieOuvrage
		 * @param  dateEdition la date d'édition de l'ouvrage
		 * affiche un message de confirmation après l'enregistrement ou un message d'erreur 
		 */
		public void nouvOuvrage(String isbn, String titre, TreeMap<String, Auteur> auteur, String editeur, String dateEdition,TreeMap<String,MotsCles> mesMotsCles) {
			// vérification de la présence des infos obligatoires et du forma
			if ((isbn.length() == 0) || (titre.length() == 0) || (auteur.isEmpty()) 
					|| (editeur.length() == 0 )|| (dateEdition.length() == 0 )){
					Message dialog = new Message("Tous les champs sont obligatoires");
					dialog.setVisible(true);
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateEdition);
				if (date == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					dialog.setVisible(true);
					}
				else if (this.getOuvrage(isbn )== null) {
				// Instanciation de l'ouvrage
					Ouvrage ouvrage = new Ouvrage(isbn, titre, auteur, editeur, date, mesMotsCles);
				// Ajout de l'ouvrage dans l'ensemble des ouvrages de la bibliothèque
					this.setOuvrage(ouvrage, isbn);
					
					Message dialog = new Message("Ouvrage enregistre");
					dialog.setVisible(true);
					this.fermerVue (this.getVueSaisieOuvrage());
					} 
					else {
						Message dialog = new Message("Ouvrage deja present");
						dialog.setVisible(true);
					}
				}
			}// Fin nouvOuvrage
		
		public void nouvPeriodique(String issn,String titre){
			
			if (this.getPeriodique(issn) == null){
				Periodique periodique = new Periodique(issn, titre);
				this.setPeriodique(periodique,issn);
				Message dialog = new Message("Periodique enregistre");
				dialog.setVisible(true);
				this.fermerVue (this.getVueSaisiePeriodique());
			}
			else {
				Message dialog = new Message("Periodique deja present");
				dialog.setVisible(true);
			}
		}//Fin nouvPeriodique
		
		public void rechPeriodique(String issn){
			Periodique per = this.getPeriodique(issn);
			if (per == null) {
				Message dialog = new Message("Periodique inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueSaisieExemplaire
				if (this.getVueSaisieParution() != null) {
				// la vue est inscrite comme observatrice de l'ouvrage	
					per.addObserver(this.getVueSaisieParution());
				// le contrôleur modifie l'état de la vue
					this.getVueSaisieParution().setEtat(Vue.inter1);
					this.getVueSaisieParution().alimentePeriodique(per);
					}
			}
			
		}//Fin rechPeriodique
		
		public void nouvParution(Periodique per, String identifiant,String dateParution,TreeMap<String,Article>articles){
			if ((identifiant.length() == 0) ||(dateParution.length() == 0 )){
					Message dialog = new Message("Tous les champs sont obligatoires");
					dialog.setVisible(true);
					}
			else {
				GregorianCalendar date = ESDate.lireDate (dateParution);
				
				if (date == null) {
					Message dialog = new Message("Le format de la date est incorrect");
					dialog.setVisible(true);
					}
				else if (this.getParution(identifiant)==null){

					Parution par = new Parution(identifiant,date, per,articles);
					this.setParution(par, identifiant);
					per.ajouterParution(identifiant, par);
					Message dialog = new Message("Parution enregistree");
					dialog.setVisible(true);
					this.fermerVue (this.getVueSaisieParution());
				}
				else {
					Message dialog = new Message("Periodique deja present");
					dialog.setVisible(true);
				}
			}
			
		}//Fin rechPeriodique
		
		public void nouvArticle(String titre, int page, TreeMap<String, Auteur> auteurs, TreeMap<String, MotsCles> motsCles){
			if ((titre.length() == 0) || (auteurs.isEmpty())|| (motsCles.isEmpty())){
					Message dialog = new Message("Tous les champs sont obligatoires");
					dialog.setVisible(true);
					}
			else {
				
				if (this.getArticle(titre)== null) {
				// Instanciation de l'ouvrage
					Article article = new Article( titre, page, auteurs,motsCles);
				// Ajout de l'ouvrage dans l'ensemble des ouvrages de la bibliothèque
					this.setArticle(article, titre);
					
					Message dialog = new Message("Article enregistre");
					dialog.setVisible(true);
					this.getVueSaisieParution().alimenteArticle(this.getArticles());
					this.fermerVue (this.getVueSaisieArticle());
					} 
					else {
						Message dialog = new Message("Article deja present");
						dialog.setVisible(true);
					}
				}
			}// Fin nouvOuvrage
		

		public boolean lectureLignesFichier(String monFichier) {
			try  {
					FileReader f = new FileReader(monFichier); 
			        BufferedReader in = new BufferedReader(f); //new FileReader("ListeAutorite.txt")
			        String ligne;
			        //MotsCles motCle;
			        while ((ligne= in.readLine()) != null)  {
			        	 MotsCles motCle = new MotsCles(ligne);
			                /*** traitement de la chaine ch ***/
			    		this.lierMotsCles(motCle,ligne);
			    		
			        }
			        in.close();
			}
		
			catch (IOException e) {
				Message dialog = new Message("Erreur de Lecture dans le fichier de Mots Cles");
				dialog.setVisible(true);
			}
		    return (_motsCles != null);
		} // Fin lectureLignesFichier

		public void nouveauAuteur(String nom, String prenom) {
			Auteur auteur = new Auteur(nom, prenom);
			this.lierAuteur(nom,prenom, auteur);
			//return auteur;
			
		}
		
		public Ouvrage rechOuvrageParAuteur(String auteur) {
			Ouvrage out = this.getOuvrage(auteur);
			if (out == null) {
				Message dialog = new Message("Ouvrage inconnu");
				dialog.setVisible(true);
			}
			else {
				// la vue courante est VueRechercheParAuteur
				// la vue est inscrite comme observatrice de l'ouvrage	
					out.addObserver(this.getVueSaisieExemplaire());
				// le contrôleur modifie l'état de la vue
					this.getVueRechercheParAuteur().alimenteListeAuteur(this.getAuteurs());
			}
			return out;
		} // Fin rechOuvrage

		
} 
		

